# -*- coding:latin-1 -*-

########################################################
# Date: 05/04/10                                       #
# Auteurs: Boris Burgarella & Rigaut Maximilien        #
# Nom: Gomoku                                          #
# Version: 1.0                                         #
# Copyright 2010: Rigaut Maximilien & Burgarella Boris #
########################################################
#    This file is part of Gomoku.
#
#    Gomoku is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    Gomoku is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with Gomoku.  If not, see <http://www.gnu.org/licenses/>.
########################################################

from random import randint,seed
seed()
def repTQTPL(x,y):
    "Initialisation des tableaux TQTPL et C2QTPL"
    global TQTPL,C2QTPL
    #---------------------------------
    # Repertorions les QTPL en ligne:
    i = 0
    decalage=1
    qt=0
    while i <= x*y-4:
        if (i+4)%x==0:          # Si on est sur la x-4 eme colone, alors
            i+=3                        # inutile de verifier les 4 suivantes
        else:
            incrementTables(i,decalage,qt)
            qt+=1
        i+=1
    #--------------------------------
    # On passe aux diagonales vers la droite:
    decalage=x+1
    i=0
    while i <= (x*(y-4))-5:
        if (i+4)%x==0:          # Si on est sur la x-4 eme colone, alors
            i+=3                        # inutile de verifier les 4 suivantes
        else:
            incrementTables(i,decalage,qt)
            qt+=1
        i+=1
    #--------------------------------
    # Et les verticaux:
    decalage=x
    i=0
    while i < (x*(y-4)):
        incrementTables(i,decalage,qt)
        qt+=1
        i+=1
    #--------------------------------
    # ....diagonales vers la gauche:
    decalage=x-1
    i=4
    while i < (x*(y-4)):
        if (i) % x == 0 :
            i+=3
        else:
            incrementTables(i,decalage,qt)
            qt+=1
        i+=1
    dp(TQTPL)
def incrementTables(i,cste,qt):
    "On met a jours les deux tables: Appelee uniquement par repTQTPL."
    global TQTPL,C2QTPL
    TQTPL= TQTPL+[[i,i+cste,i+2*cste,i+3*cste,i+4*cste]]
    for j in range(5):
        C2QTPL[i+j*cste]=C2QTPL[i+j*cste]+[qt+1]
def clearAllVars():
    pass
def generationTables():
    global taille,TQTPL,C2QTPL
    TQTPL=[[]]                          # L'ensemble des quintuplets: A chaque quintuplet on associe un UNIQUE indice.
    C2QTPL=[[]]*(taille[0]*taille[1])   # Liste de liste de numeros de quintuples: Initialisation
    repTQTPL(taille[0],taille[1])
    evalQ=len(TQTPL)*[5*preset[0]]      # Valeur de chaque quintuplet
    xy=taille[0]*taille[1]
    evalC=[0]*xy                        # Valeur de chaque case
    i=0
    while i < xy:
        for qtpl in C2QTPL[i]:
            evalC[i]=evalC[i]+7*5
        i+=1
    return TQTPL,C2QTPL,evalC,evalQ
def majTables(nCase, signe=1):
    global C2QTPL,evalC,TQTPL,evalQ,case,game
    count = 0
    # Pour chaque quintuplet concerne
    for qtpl in C2QTPL[nCase]:
        caseX = 0
        case0 = 0
        # On essaye de sommer le nombre de cases en faveur de 0 (Joueur) ou 1 (IA)
        try:
            for C in TQTPL[qtpl]:
                if case[C] == 1:
                    caseX += 1
                if case[C] == 2:
                    case0 += 1
        except:
            print 'Erreur: ',qtpl,'Bug',TQTPL[qtpl-1]
        if caseX == 5 and tour%2==0:
            gagnerJoueur(0,qtpl)
            game=False
            return 0
        if case0 == 5 and tour%2==1:
            gagnerJoueur(1,qtpl)
            game=False
            return 1
        if caseX != 0:
            evalQ[qtpl] = signe*preset[1][caseX-1]
        if case0 != 0:
            evalQ[qtpl] = signe*preset[2][case0-1]
        if caseX != 0 and case0 != 0:
            evalQ[qtpl] = signe*(-preset[2][case0-1]-preset[1][caseX-1])
        for C in TQTPL[qtpl]:
            if case[C] == 0:
                evalC[C] += evalQ[qtpl]
            else:
                evalC[C] = -1
def printEval(cases):
    if not debug:
        return 0
    ligne=""
    i=0
    while i <len(cases):
        ligne+='|'+str(cases[i])+' '*(6-len(str(cases[i])))
        if (i+1)%taille[0]==0 and i!=0:
            print ligne+'|'
            ligne=''
        i+=1
    print ligne
    print ""
def choixcaseIA() :
    "Donne le numero de case d'une des plus haute cases valables pour l'IA"
    global evalC
    plateauchoix = evalC
    maxC = 0
    listechoix = []
    plein=True #On suppose que l'on ne peux plus rien jouer de >0
    for i in plateauchoix:
        if i > maxC:
            maxC = i
            plein=False
    i,maxV=0,len(plateauchoix)
    while i < maxV:
        if plateauchoix[i] >= maxC*level:
            listechoix += [i]
        i+=1
    if plein:
        return testNul()
    else:
        choix = randint(0,(len(listechoix)-1))
        return listechoix[choix]
def testNul():
    "Teste si la partien est un match nul"
    ####
    # Initialisation
    nul=True
    listechoix,maxV = [],len(case)
    i=0
    #####
    # Parcourt
    while i < maxV:
        if case[i]==0:
            nul=False
        i+=1
    #####
    # Traitement
    if nul:
        Application.nul()
        return -1
    else:
        minC=-preset[2][3]
        i=0
        while i < maxV:
           if  minC<evalC[i] and case[i]==0:
                minC = evalC[i]
           i+=1
        i=0
        #print minC
        maxV=len(evalC)
        while i < maxV:
            if evalC[i] >= minC*level and case[i]==0:
                listechoix += [i]
            i+=1
        choix = randint(0,(len(listechoix)-1))
        #print choix,listechoix
        return listechoix[choix]
def gagnerJoueur(player,qtpl):
    Application.Gagne(player,TQTPL[qtpl])
    